package com.bm.service.Impl;

import com.bm.enums.ItemType;
import com.bm.enums.ModifyType;
import com.bm.enums.OrderStatus;
import com.bm.exception.BusinessException;
import com.bm.exception.ExceptionCode;
import com.bm.model.Item;
import com.bm.model.Order;
import com.bm.model.OrderModification;
import com.bm.service.IEditService;
import com.bm.service.IOrderRepository;
import com.bm.util.ItemUtil;
import com.bm.util.LocalDateTimeUtil;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;

import static com.bm.util.ItemUtil.icedCoffee;

public class EditServiceImpl implements IEditService {

    //orders 是一个 ConcurrentHashMap，用于存储订单数据。键是订单 ID，值是订单对象。
    // ConcurrentHashMap 提供了线程安全的存储，
    // 但在高并发场景下可能仍存在一些竞争条件，因此该实现主要适用于测试环境。
    private final Map<String, Order> orders = new ConcurrentHashMap<>();
    protected final IOrderRepository repository;

    public EditServiceImpl(IOrderRepository repository) {
        this.repository = repository;
    }

    /**
     *
     * @param orderId  订单ID
     * @param request  修改类型（整单替换或部分修改）
     * @param itemsToAdd 要添加的商品列表
     * @param itemsToRemove 要删除的商品列表
     * @param itemToUpdate 要修改数量的商品
     * @param newQuantity 新的数量
     * @return 订单
     */

    Order modifyOrder(String orderId, ModifyType request,
                      List<Item> itemsToAdd, List<Item> itemsToRemove,
                      Item itemToUpdate, int newQuantity) {


        //1.检查订单是否存在
        Order order = repository.findById(orderId);
        if (order == null) {
            throw new BusinessException(ExceptionCode.ORDER_NOT_FOUND);
        }

        // 2. 检查订单状态
        if (order.getStatus() == OrderStatus.PAID) {
            throw new BusinessException(ExceptionCode.MODIFY_FORBIDDEN);
        }


        // 3. 处理不同类型的修改
        OrderModification modification = new OrderModification(orderId);
        switch (request) {
            case FULL_REPLACE:
                // 处理整单替换逻辑
                handleFullReplace(order,itemsToAdd);
                break;
            case PARTIAL_MODIFY:
                // 处理部分修改逻辑
                handlePartialModification(order, itemsToAdd, itemsToRemove, itemToUpdate, newQuantity,modification);
                break;
            default:
                throw new IllegalArgumentException("Invalid modify type");
        }
        //4. 生成修改差异单
        OrderModification(modification);
        // 5. 商家审批

        // 5. 商家审批
        if (approveModification(order)) {
            // 审批通过
            updateOrderStatus(order, OrderStatus.CREATED);
            executeModification(order, modification);
            generateOperationLog(order, modification,"pass！");
        } else {
            // 审批未通过
            generateOperationLog(order, modification, "Modification not approved");
        }
        return order;
    }
    // 生成操作日志
    private void generateOperationLog(Order order, OrderModification modification, String message) {
        // 生成操作日志（这里简化处理，实际应存储到数据库或日志服务）
        System.out.println("Operation Log: " + message);
        System.out.println("Order ID: " + order.getOrderId());
        System.out.println("Modification Details: " + modification);
        System.out.println("Timestamp: " + LocalDateTimeUtil.getTimestamp(LocalDateTime.now()));
    }

    // 更新订单信息
    private void executeModification(Order order, OrderModification modification) {
       //总金额
        order.setTotalPrice(modification.getNewTotalPrice());
        //修改时间
        order.setCreateTime(modification.getModificationTime());
        repository.save(order);
    }

    //修改订单状态
    private void updateOrderStatus(Order order, OrderStatus created) {
        order.setStatus(created);
        repository.updateStatus(order.getOrderId(),created);
    }

    private boolean approveModification(Order order) {
        return true; // 假设审批通过
    }

    // 处理整单替换
    private void handleFullReplace(Order order, List<Item> newItems) {
        // 清空原订单商品
        order.setItems(newItems);
        //检查新订单的有效性
        validateItems(newItems);
    }

    // // 处理部分修改
    private void handlePartialModification(Order order,List<Item> itemsToAdd,List<Item> itemsToRemove,
                                           Item itemsToUpdate,int newQuantity,OrderModification modification ) {
        // 添加商品
        if(itemsToAdd != null && !itemsToAdd.isEmpty()){
            //  检查商品有效性
            validateItems(itemsToAdd);
            order.getItems().addAll(itemsToAdd);
        }
        // 删除商品
        if(itemsToRemove != null && !itemsToRemove.isEmpty()){
            order.getItems().removeAll(itemsToRemove);
        }
        // 修改商品数量
        if (itemsToUpdate != null){
            Item existingItem = order.getItems().stream()
                    .filter(item -> item.getId().equals(itemsToUpdate.getId()))
                    .findFirst().orElse(null);
            if (existingItem !=null){
                existingItem.setQuantity(newQuantity);
            }
        }
    }
    // 修改差异单
    private void OrderModification(OrderModification modification) {
// 计算新总价
        double newTotalPrice = modification.getAddedItems().stream().mapToDouble(item ->item.getPrice()
        * item.getQuantity()).sum();
         modification.setNewTotalPrice(newTotalPrice);
        // 计算优惠变化
        double discountChange = modification.getOriginalTotalPrice() - newTotalPrice;
        modification.setDiscountChange(discountChange);
        System.out.println("Modification  Sheet: "+modification);

    }
//有效
    private void validateItems(List<Item> items) {
        for (Item item:items){
            Item itemInfo = ItemUtil.getItemInfo(item.getId());
            if (itemInfo == null){
                throw new BusinessException(ExceptionCode.ITEM_INVALID);
            }
        }
    }

}
